home *** CD-ROM | disk | FTP | other *** search
/ FM Towns: Free Software Collection 6 / FM Towns Free Software Collection 6.iso / t_os / book / src / cons.c < prev    next >
C/C++ Source or Header  |  1993-07-08  |  17KB  |  750 lines
  1. /*
  2.  *  console low I/O
  3. */
  4.  
  5. #include    <stdio.h>
  6. #include    <stdlib.h>
  7. #include    <string.h>
  8. #include    <string.h>
  9. #include    <ctype.h>
  10. #include    <egb.h>
  11. #include    <msdos.cf>
  12. #include    <mos.h>
  13. #include    <fmc.h>
  14. #include    "book.h"
  15. #include    "oaklib.h"
  16. #include    "cons.h"
  17. #include    "keyio.h"
  18. #include    "lib.h"
  19. #include    "mouse.h"
  20.  
  21.  
  22. #define MODE_X 560
  23. #define MODE_Y 452
  24.  
  25. #define FSIZE   16      /*  フォント・サイズ  */
  26. #define PIX_BYTE 1      /* 画面モ－ドにより変化 16色=1 256色=1 32K色=2 */
  27.  
  28. #define FNT_X   8
  29. #define FNT_Y   16
  30.  
  31. #define LINE_MAX    128
  32.  
  33. #define OPEN    wp->opened
  34. #define TOP_X   wp->top_x
  35. #define TOP_Y   wp->top_y
  36. #define BTM_X   wp->btm_x
  37. #define BTM_Y   wp->btm_y
  38. #define SIZ_X   wp->siz_x
  39. #define CUR_X   (*wp->cur_x)
  40. #define _CUR_X  wp->cur_x
  41. #define CUR_POS wp->cur_pos
  42. #define CUT_X   wp->cut_x
  43. #define CUT_POS wp->cut_pos
  44. #define KAN_COD wp->kan_cod
  45. #define EDITBUF wp->editbuf
  46. #define DSP_X   wp->dsp_x
  47. #define DSP_Y   wp->dsp_y
  48. #define DSP_LEN wp->dsp_len
  49.  
  50. typedef struct _WP
  51. {
  52.     short   opened ;
  53.     short   top_x, top_y ;
  54.     short   btm_x, btm_y ;
  55.     short   siz_x ;
  56.     int     *cur_x ;
  57.     short   cur_pos ;
  58.     short   cut_x, cut_pos ;
  59.     short   kan_cod ;
  60.     char    *editbuf ;
  61.     short   dsp_x, dsp_y ;
  62.     short   dsp_len ;
  63. } WIND_t ;
  64.  
  65. static  WIND_t  act_wind = { FALSE,
  66.                              0,0, 0,0, 0, NULL, 0,-1,-1, 0, NULL, 0,0,0 } ;
  67. static  WIND_t  *wp = &act_wind ;
  68.  
  69. static  char    kan_mode[16];
  70. static  char    cutbuf[LINE_MAX];
  71. static  char    ktype[LINE_MAX];
  72. static  char    linebuf[LINE_MAX];
  73. static  int     linelen = 0;
  74.  
  75.  
  76. void    typecheck( char *type, char *buf, int width )
  77. {
  78.     while( width-- > 0 )
  79.     {
  80.         if( iskanji( *buf ) && iskanji2( *(buf+1) ) )
  81.         {
  82.             *type++ = IS_KANJI1 ;
  83.             *type   = IS_KANJI2 ;
  84.             buf++ ;
  85.             width-- ;
  86.         }
  87.         else
  88.             *type = IS_ANK ;
  89.         buf++, type++ ;
  90.     }
  91.     *type = IS_ANK ;
  92. }
  93.  
  94. typedef enum { CUR_DISP, CUR_OFF } cursor ;
  95.  
  96. static  void    cur_dsp( cursor sw )
  97. {
  98.     static  int     pos, cpos ;
  99.     auto    int     TOPx = TOP_X, y ;
  100.  
  101.     if( sw == CUR_DISP )
  102.     {
  103.         TOPx -= ( TOPx % 2 ) ;
  104.  
  105.         pos = CUR_X * FNT_X + TOPx ;
  106.         if( CUT_X >= 0 )
  107.             cpos = CUT_X * FNT_X + TOPx ;
  108.     }
  109.  
  110.     y = ( CUT_POS >= 0 ) ? (DSP_Y+7):(DSP_Y+14) ;
  111.     box( pos,y, pos+FNT_X-1,y+1, 2,-1,MODE_XOR ) ;
  112.  
  113.     if( CUT_POS >= 0 && CUT_POS < CUR_POS )
  114.     {
  115.         EGB_writeMode( gwork, MODE_XOR ) ;
  116.         pbox( cpos,DSP_Y, pos-1,DSP_Y+15, 2,2 ) ;
  117.         EGB_writeMode( gwork, MODE_PSET ) ;
  118.     }
  119. }
  120.  
  121.  
  122. static  void    cflush( void )
  123. {
  124.     int     i ;
  125.     char    *p, buf[3] = "^ " ;
  126.  
  127.     cur_dsp( CUR_OFF ) ;
  128.     if( DSP_LEN > 0 )
  129.     {
  130.         DSP_X = CUR_POS * FNT_X + TOP_X ;
  131.         wrt( (char *)&linebuf[CUR_POS], DSP_X,DSP_Y, CHR_COL,BAK_COL,FSIZE ) ;
  132.         DSP_LEN = 0 ;
  133.  
  134.         for( i=0, p=(char *)&linebuf[CUR_POS] ; *p ; p++, i++ )
  135.             if( *p == CTRL_PRE )
  136.             {
  137.                 buf[1] = *(p+1) ;
  138.                 wrt( buf, DSP_X+i*8,DSP_Y, CTRL_COL,BAK_COL,FSIZE ) ;
  139.             }
  140.     }
  141.     CUR_POS = CUR_X ;
  142.     CUT_POS = CUT_X ;
  143.     cur_dsp( CUR_DISP ) ;
  144. }
  145.  
  146. static  void    cut_paste( int sw )
  147. {
  148.     int     color ;
  149.  
  150.     if( sw == TRUE )    /*  開始  */
  151.     {
  152.         pbox( 272,MODE_Y-2, 272+96,MODE_Y+16+1, CHR_COL,CHR_COL ) ;
  153.  
  154.         wrt( "範囲指定中", 280,MODE_Y, BAK_COL,CHR_COL, 16 ) ;
  155.  
  156.         CUT_X = CUR_X ;
  157.     }
  158.     else                /*  終了  */
  159.     {
  160.         color = ( writepage == 0 ) ? 15 : 0 ;
  161.  
  162.         pbox( 272,MODE_Y-2, 272+96,MODE_Y+16+1, color,color ) ;
  163.  
  164.         CUT_X = -1 ;
  165.     }
  166. }
  167.  
  168. void    wind_close( void )
  169. {
  170.     if( OPEN )
  171.     {
  172.         OPEN = FALSE ;
  173.         MOS_disp( MOS_OFF ) ;
  174.         cflush() ;
  175.         if( CUT_X != -1 )
  176.             cut_paste( FALSE ) ;
  177.         cur_dsp( CUR_OFF ) ;
  178.         MOS_disp( MOS_ON ) ;
  179.         strcpy( EDITBUF, linebuf ) ;
  180.     }
  181. }
  182.  
  183. int     wind_open( int x,int y, int len,int *curpos, char *init )
  184. {
  185.     wind_close() ;
  186.  
  187.     MOS_disp( MOS_OFF ) ;
  188.  
  189.     OPEN = TRUE ;
  190.     TOP_X = x ;
  191.     TOP_Y = y ;
  192.     BTM_X = x + len*8 ;
  193.     BTM_Y = y + 15 ;
  194.     SIZ_X = len + 1 ;
  195.     _CUR_X = curpos ;
  196.     CUT_X = CUT_POS = -1 ;
  197.     CUR_POS = 0 ;
  198.     KAN_COD = 0 ;
  199.     DSP_X = TOP_X ;
  200.     DSP_Y = TOP_Y ;
  201.     DSP_LEN = 0 ;
  202.     EDITBUF = init ;
  203.  
  204.     if( init == NULL )
  205.     {
  206.         linebuf[0] = '\0' ;
  207.         linelen = 0 ;
  208.         CUR_X = 0 ;
  209.     }
  210.     else
  211.     {
  212.         strcpy( linebuf, init ) ;
  213.         linelen = strlen( init ) ;
  214.         typecheck( ktype, linebuf, linelen ) ;
  215.         DSP_LEN = 1 ;
  216.         if( CUR_X > linelen )
  217.             CUR_X = linelen ;
  218.         if( ktype[CUR_X] == IS_KANJI2 )
  219.             CUR_X -- ;
  220.     }
  221.  
  222.     cur_dsp( CUR_DISP ) ;
  223.     cflush() ;
  224.  
  225.     MOS_disp( MOS_ON ) ;
  226.  
  227.     return 0 ;
  228. }
  229.  
  230. static  int     ins_char( char str[] )
  231. {
  232.     REGS    int     i ;
  233.  
  234.     if( linelen >= SIZ_X-1 )
  235.         return -1 ;
  236.  
  237.     for( i = linelen ; i >= 0 ; i -- )
  238.         str[i+1] = str[i] ;
  239.     linelen ++ ;
  240.  
  241.     return 0 ;
  242. }
  243.  
  244. static  int    del_char( int pos )
  245. {
  246.     REGS    int     i, len ;
  247.  
  248.     len = ( ktype[pos]==IS_KANJI1 || linebuf[pos]==CTRL_PRE ) ? 2 : 1 ;
  249.  
  250.     for( i = pos ; i < linelen ; i ++ )
  251.         linebuf[i] = linebuf[i+len] ;
  252.     if( linelen > 0 )
  253.         linelen -= len ;
  254.  
  255.     return len ;
  256. }
  257.  
  258. static  int     cnvhex( char *str )
  259. {
  260.     static  char    *base = "0123456789ABCDEF" ;
  261.             int     code = 0 ;
  262.             char    *p ;
  263.  
  264.     jstrupr( str ) ;
  265.     for( ; *str ; str++ )
  266.     {
  267.         code <<= 4 ;
  268.         if( ( p = strchr( base, *str ) ) == NULL )
  269.             return -1 ;
  270.         code += (int)(p - base) ;
  271.     }
  272.  
  273.     return code ;
  274. }
  275. static  void    beep( void )
  276. {
  277. extern  void    write(int,char *,int);
  278.  
  279.     write( 1, "\x07", 1 ) ;
  280. }
  281.  
  282. static  void    chr_out( u_char ch )
  283. {
  284.     if( CUR_X + 1 < SIZ_X )
  285.     {
  286.         if( ins_char( (char *)&linebuf[CUR_X] ) != -1 )
  287.         {
  288.             linebuf[CUR_X ++] = ch ;
  289.             /* DSP_BUF[ */ DSP_LEN++ /* ] = ch */ ;
  290.             typecheck( ktype, linebuf, linelen ) ;
  291.             return ;
  292.         }
  293.     }
  294.     beep() ;
  295. }
  296.  
  297. static  void    key_del( void )
  298. {
  299.     int     len ;
  300.  
  301.     if( linelen <= CUR_X )
  302.         return ;
  303.     len = del_char( CUR_X ) ;
  304.     linebuf[linelen] = ' ' ;
  305.     if( len == 2 )
  306.         linebuf[linelen+1] = ' ', linebuf[linelen+2] = '\0' ;
  307.     else
  308.         linebuf[linelen+1] = '\0' ;
  309.     CUR_POS = CUR_X ;
  310.     DSP_LEN = 1 ;
  311.     cflush() ;
  312.     linebuf[linelen] = '\0' ;
  313.     typecheck( ktype, linebuf, linelen ) ;
  314. }
  315.  
  316. static  void    key_left( void )
  317. {
  318.     if( CUR_X > 0 )
  319.     {
  320.         CUR_X-- ;
  321.         if( CUR_X > 0 &&
  322.                 ( ktype[CUR_X]==IS_KANJI2 || linebuf[CUR_X-1]==CTRL_PRE ) )
  323.             CUR_X-- ;
  324.     }
  325. }
  326.  
  327. static  void    _inpch( int ch )
  328. {
  329. u_char  *p;
  330. char    code_buf[3];
  331. short   code;
  332. int     i;
  333.  
  334.     if (OPEN == FALSE)      /*  window がオープンしてなければパス  */
  335.         return;
  336.  
  337.     switch (ch)
  338.     {
  339.       case 0x0162:      /*  PF6 [範囲指定開始]  */
  340.         if (CUT_X < 0)
  341.             cut_paste(TRUE);
  342.         else
  343.             cut_paste(FALSE);
  344.         break;
  345.  
  346.       case 0x0163:      /*  PF7 [カット]  */
  347.         if (CUT_POS != -1)
  348.             if (CUT_POS < CUR_POS)              /*  指定されている  */
  349.             {
  350.                 strncpy(cutbuf, &linebuf[CUT_POS], CUR_POS-CUT_POS);
  351.                 cutbuf[CUR_POS-CUT_POS] = '\0';
  352.                 cut_paste(FALSE);
  353.  
  354.                 CUR_X = CUT_POS;
  355.                 for (i = 0; i < jstrlen(cutbuf); i++)
  356.                     key_del();
  357.             }
  358.             else
  359.                 cut_paste(FALSE);
  360.         break;
  361.  
  362.       case 0x0164:      /*  PF8 [コピー]  */
  363.         if (CUT_POS != -1)
  364.         {
  365.             if (CUT_POS < CUR_POS)              /*  指定されている  */
  366.             {
  367.                 strncpy(cutbuf, &linebuf[CUT_POS], CUR_POS-CUT_POS);
  368.                 cutbuf[CUR_POS-CUT_POS] = '\0';
  369.             }
  370.             cut_paste(FALSE);
  371.         }
  372.         break;
  373.  
  374.       case 0x0165:      /*  PF9 [ペースト]  */
  375.         if (CUT_POS != -1)
  376.         {
  377.             cut_paste(FALSE);
  378.         }
  379.         else if(strlen(cutbuf) > 0)
  380.         {
  381.             for (p = (u_char *)cutbuf; *p != '\0'; p++)
  382.                 inpch(*p);
  383.         }
  384.         break;
  385.  
  386.       case 0x014E:      /*  HOME [先頭・末尾へ移動]  */
  387.         if (CUR_X > 0)
  388.             CUR_X = 0;
  389.         else
  390.             CUR_X = linelen;
  391.         cflush();
  392.         break;
  393.  
  394.       case 0x000B:      /*  CTRL-K [行末まで削除] */
  395.         while (CUR_X < linelen)
  396.             key_del();
  397.         break;
  398.  
  399.       case 0x0016:      /*  CTRL-V [制御文字入力]  */
  400.         pbox(264,MODE_Y-2, 264+112,MODE_Y+16+1, CHR_COL,CHR_COL);
  401.         wrt("制御文字入力", 272,MODE_Y, BAK_COL,CHR_COL, 16);
  402.  
  403.         code_buf[2] = '\0' ;
  404.         code = -1;
  405.         if (isxdigit(code_buf[0] = getch())) {
  406.             if (isxdigit(code_buf[1] = getch()))
  407.                 code = cnvhex(code_buf);
  408.         } else if (code_buf[0] < 0x20)
  409.             code = code_buf[0];
  410.  
  411.         if (code != -1)
  412.         {
  413.             if (code < 0x20)            /*  制御文字  */
  414.                 chr_out(CTRL_PRE), chr_out(code|0x40);
  415.             else if (!iskanji(code))    /*  一般文字  */
  416.                 chr_out(code);
  417.             else
  418.                 beep();
  419.         }
  420.  
  421.         int color = (writepage == 0) ? 15 : 0;
  422.         pbox(264,MODE_Y-2, 272+112,MODE_Y+16+1, color,color);
  423.         break;
  424.  
  425.       case 0x314F:      /*  CTRL＋シフト＋左カーソル  */
  426.       case 0x114F:      /*  シフト＋左カーソル  */
  427.         CUR_X = 0;
  428.       case 0x014F:      /*  左カーソル  */
  429.       case 0x0013:      /*  CTRL-S  */
  430.         key_left();
  431.         cflush();
  432.         break;
  433.  
  434.       case 0x3151:      /*  CTRL＋シフト＋右カーソル  */
  435.       case 0x1151:      /*  シフト＋右カーソル  */
  436.         CUR_X = linelen;
  437.       case 0x0151:      /*  右カーソル  */
  438.       case 0x0004:      /*  CTRL-D  */
  439.         if (CUR_X < linelen)
  440.         {
  441.             if (ktype[CUR_X] == IS_KANJI1 || linebuf[CUR_X] == CTRL_PRE)
  442.                 CUR_X++;
  443.             CUR_X++;
  444.         }
  445.         cflush();
  446.         break;
  447.  
  448.       case 0x010F:      /*  BS  */
  449.       case 0x0008:      /*  CTRL-H  */
  450.         if (CUR_X > 0)
  451.         {
  452.             key_left();
  453.             key_del();
  454.         }
  455.         break;
  456.  
  457.       case 0x0015:      /*  CTRL_U [行頭まで削除]  */
  458.       case 0x0018:      /*  CTRL-X  */
  459.         while (CUR_X > 0)
  460.         {
  461.             key_left();
  462.             key_del();
  463.         }
  464.         break;
  465.  
  466.       case 0x014B:      /*  DEL  */
  467.       case 0x0007:      /*  CTRL-G   */
  468.         key_del();
  469.         break;
  470.  
  471.       default:
  472.         if ((ch & 0x0100) != 0) /* その他の制御キー */
  473.             break;
  474.  
  475.         if (KAN_COD != 0)
  476.         {
  477.             if (iskanji2(ch))
  478.             {
  479.                 if (CUR_X == (SIZ_X - 1))
  480.                     chr_out(' ');
  481.                 chr_out(KAN_COD);
  482.                 chr_out(ch);
  483.                 KAN_COD = 0;
  484.                 return;
  485.             }
  486.             KAN_COD = 0;
  487.         }
  488.         if (iskanji(ch))
  489.         {
  490.             KAN_COD = ch;
  491.             return;
  492.         }
  493.         if (ch >= ' ')
  494.         {
  495.             chr_out(ch);
  496.             return;
  497.         }
  498.     }
  499. }
  500.  
  501. void    inpch(int ch)
  502. {
  503.     MOS_disp(MOS_OFF);
  504.  
  505.     _inpch(ch);
  506.     cflush();
  507.  
  508.     MOS_disp(MOS_ON);
  509. }
  510.  
  511. /*
  512. void    cputs(char *str)
  513. {
  514.     while (*str != '\0')
  515.         inpch((unsigned char)*(str++));
  516. }
  517.  
  518. void    cprintf(char *form,...)
  519. {
  520. static  char    tmpbuf[256];
  521. va_list arg;
  522.  
  523.     va_start(arg, form);
  524.     vsprintf(tmpbuf, form, arg);
  525.     cputs(tmpbuf);
  526.     va_end(arg);
  527. }
  528. */
  529.  
  530.  
  531. /*
  532.  0   透過色 or 黒            8  テキスト背景色
  533.  1   黒                      9  テキスト改行色
  534.  2   テキスト文字色(XOR時)  10  テキスト文字色
  535.  3   明るい黒               11      --
  536.  4   暗い緑                 12      --
  537.  5   暗いシアン             13  暗い赤
  538.  6   暗い黄色               14  暗いマゼンダ
  539.  7   暗い白                 15  明るい白        */
  540. static  u_short fortbl[] =
  541. {
  542.     BAK_COL,BAK_COL,BAK_COL,BAK_COL,BAK_COL,BAK_COL,BAK_COL,BAK_COL,
  543.     BAK_COL,BAK_COL,BAK_COL,BAK_COL,BAK_COL,BAK_COL,BAK_COL,BAK_COL,
  544. } ;
  545. static  u_short baktbl[] =
  546. {
  547.     CHR_COL,CHR_COL,4,14,14,5,CHR_COL,                      CHR_COL,
  548.     CHR_COL,CHR_COL,CHR_COL,CHR_COL,CHR_COL,CHR_COL,CHR_COL,CHR_COL,
  549. } ;
  550.  
  551. /*        0    読み
  552.         1    読み残し
  553.         2    未確定文字列
  554.         3    仮確定文字列
  555.         4    変換対象文節
  556.         5    現変換対象文節
  557.         6    カ－ソル位置
  558. */
  559. static  void    KAN_putstr( int pos, int len, char *str, char *att )
  560. {
  561.     static  int     bak_len = 0 ;
  562.     static  char   *bak_buf[128] = { NULL } ;
  563.     static  char    para[16] ;
  564.     auto    int     i, x, y, n, m ;
  565.     auto    char    *p ;
  566.     auto    int     TOPx = TOP_X ;
  567.  
  568.     if( OPEN == FALSE )
  569.         return ;
  570.  
  571.     if( ( TOPx % 2 ) == 1 )
  572.         TOPx -- ;
  573.  
  574.     MOS_disp( MOS_OFF ) ;
  575.  
  576.     for( i = 0 ; i < bak_len ; i++ )    /*  文字列消去  */
  577.     {
  578.         EGB_putBlock( gwork, 0, bak_buf[i] ) ;
  579.         free( bak_buf[i] ) ;
  580.     }
  581.     /* cflush() ; */    /*  これをやると飛びます  */
  582.     bak_len = 0 ;
  583.     x = CUR_X ;     y = 0 ;
  584.     if( ( m = len ) > 0 && len == pos )
  585.         m ++ ;
  586.  
  587.     for( i = 0 ; i < m ; i += n )   /*  文字列表示  */
  588.     {
  589.         n = ( i < len && iskanji( *str ) ) ? 2 : 1 ;
  590.  
  591.         if( ( ( x + n ) * 8 + TOPx ) > 638 )
  592.         {
  593.             x = 0 ;
  594.             y ++ ;
  595.         }
  596.  
  597.         if( ( p = (char *)malloc(FNT_X * FNT_Y * n * PIX_BYTE + 14)) == NULL )
  598.             break ;
  599.  
  600.         DWORD(p+0) = (unsigned int)(p+14) ;
  601.         WORD(p+4) = 0x014 ;             /* Data Selecter */
  602.         WORD(p+6) = TOPx + x * FNT_X ;
  603.         WORD(p+8) = TOP_Y + y * FNT_Y ;
  604.         WORD(p+10) = WORD(p+6) + n * FNT_X - 1 ;
  605.         WORD(p+12) = WORD(p+8) + FNT_Y - 1 ;
  606.         EGB_getBlock( gwork, p ) ;
  607.         bak_buf[bak_len++] = p ;
  608.  
  609.         if( i < len )
  610.         {
  611.             para[0] = *str ;
  612.             if( n == 2 )
  613.                 para[1] = *(str+1), para[2] = '\0' ;
  614.             else
  615.                 para[1] = '\0' ;
  616.             wrt( para, WORD(p+6),WORD(p+8),
  617.                                     fortbl[*att],baktbl[*att], FSIZE ) ;
  618.             str += n ;
  619.             att += n ;
  620.         }
  621.  
  622.         if( i == pos )
  623.         {
  624.             EGB_writeMode( gwork, MODE_XOR ) ;
  625.             pbox( WORD(p+6),WORD(p+8)+14, WORD(p+6)+7,WORD(p+8)+15, 2,2 ) ;
  626.             EGB_writeMode( gwork, MODE_PSET ) ;
  627.         }
  628.  
  629.         x += n ;
  630.         if( ( x * 8 + TOPx ) >= 638 )
  631.         {
  632.             x = 0 ;
  633.             y ++ ;
  634.         }
  635.     }
  636.  
  637.     MOS_disp( MOS_ON ) ;
  638. }
  639.  
  640.  
  641. static  void    KAN_putsys(int len, char *str, char *att)
  642. {
  643. const           X_POS = 16, Y_POS = 460;
  644. static  int     bak_len = 0;
  645. static  char    *bak_buf = NULL;
  646.         char    tmpbuf[4];
  647.         int     i, x, n;
  648.  
  649.     if (OPEN == FALSE)
  650.         return;
  651.  
  652.     MOS_disp(MOS_OFF);
  653.  
  654.     if (bak_len > 0)
  655.     {
  656.         DSP_putBlock(X_POS,Y_POS, bak_len * FNT_X - 1,FNT_Y - 1, bak_buf);
  657.         free(bak_buf);
  658.     }
  659.     bak_len = 0;
  660.  
  661.     if (len == 0)
  662.     {
  663.         MOS_disp(MOS_ON);
  664.         return;
  665.     }
  666.  
  667.     bak_buf = malloc(FNT_X * FNT_Y * (((len + 8) / 8) * 8) * PIX_BYTE);
  668.     if (bak_buf == NULL)
  669.     {
  670.         MOS_disp(MOS_ON);
  671.         return;
  672.     }
  673.     DSP_getBlock(X_POS,Y_POS, len * FNT_X - 1,FNT_Y - 1, bak_buf);
  674.     bak_len = len;
  675.  
  676.     for (x = X_POS, i = 0; i < len; i += n)
  677.     {
  678.         n = iskanji(*str) ? 2 : 1;
  679.  
  680.         tmpbuf[0] = *str;
  681.         if (n == 2)
  682.             tmpbuf[1] = *(str+1), tmpbuf[2] = '\0';
  683.         else
  684.             tmpbuf[1] = '\0';
  685.         wrt(tmpbuf, x,Y_POS, fortbl[*att], baktbl[*att], FSIZE);
  686.  
  687.         str += n;
  688.         att += n;
  689.         x += (FNT_X * n);
  690.     }
  691.  
  692.     MOS_disp(MOS_ON);
  693. }
  694.  
  695. static  void    KAN_putmode(int mode, int shift_status, char *str)
  696. {
  697.     mode = mode, shift_status = shift_status;   /* Warnings 回避 */
  698.     strcpy(kan_mode, str);
  699.  
  700.     if (OPEN == FALSE)
  701.         return;
  702.  
  703.     MOS_disp(MOS_OFF);
  704.     KAN_dispMode();
  705.     MOS_disp(MOS_ON);
  706. }
  707.  
  708.  
  709.  
  710. static  int     using_kkc = FALSE;
  711.  
  712. void    KAN_start(void)
  713. {
  714.     KYB_init();
  715.     KYB_clic(1);    /* clic off */
  716.  
  717.     KAN_open(KAN_putstr, KAN_putsys, KAN_putmode);
  718.  
  719.     KAN_setposMode(MODE_X, MODE_Y);
  720.  
  721.     using_kkc = TRUE;
  722. }
  723.  
  724. void    KAN_end(void)
  725. {
  726.     using_kkc = FALSE;
  727.  
  728.     KAN_close();
  729. }
  730.  
  731.  
  732. static  int     mode_x_pos, mode_y_pos;
  733.  
  734. void    KAN_setposMode(int x, int y)    /* モード表示位置を指定 */
  735. {
  736.     mode_x_pos = x;
  737.     mode_y_pos = y;
  738. }
  739.  
  740. void    KAN_dispMode(void)          /* モードを再表示 */
  741. {
  742.     if (using_kkc != TRUE)
  743.         return;
  744.  
  745.     pbox(mode_x_pos-4,mode_y_pos-2, mode_x_pos+71,mode_y_pos+16+1,
  746.                                                             BLACK,BAK_COL);
  747.     wrt(kan_mode, mode_x_pos,mode_y_pos, CHR_COL,BAK_COL, FSIZE);
  748. }
  749.  
  750.